WOLF core
WOLF: A Modular Estimation Framework for Robotics
XXXXXXXXXXXXXXXXXXXXXXXXvoid(0)" frameborder="0" name="MSearchResults" id="MSearchResults">
SE2.h File Reference
#include "core/common/wolf.h"
#include "core/math/rotations.h"
#include "core/composite/vector_composite.h"
#include <Eigen/Geometry>
#include <Eigen/Dense>

Go to the source code of this file.

Namespaces

namespace  wolf
 
namespace  wolf::SO2
 
namespace  wolf::SE2
 

Functions

template<typename T >
Matrix< T, 2, 2 > wolf::SO2::exp (const T theta)
 
template<class T >
Matrix< T, 2, 2 > wolf::SE2::skew (const T &t)
 
template<class D >
Matrix< typename D::Scalar, 2, 1 > wolf::SE2::skewed (const MatrixBase< D > &t)
 Compute [1]_x * t = (-t.y ; t.x) More...
 
template<typename T >
Matrix< T, 2, 2 > wolf::SE2::V_helper (const T theta)
 V(theta) matrix, so that exp([rho, theta]) = [V(theta) * rho, theta]. See [1] eq. 158. More...
 
template<typename T >
Matrix< T, 2, 2 > wolf::SE2::V_inv_helper (const T theta)
 Inverse of V(theta), so that log([p, theta]) = [V(theta).inv * p, theta]. More...
 
template<class D , typename T >
Matrix< T, 2, 1 > wolf::SE2::J_Vp_theta (const MatrixBase< D > &p, const T theta)
 Jacobian of V(theta)*p wrt theta. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_left (const MatrixBase< D > &tangent)
 Left Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 164. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_right (const MatrixBase< D > &tangent)
 Right Jacobian of SE(2), with tangent = [rho, theta]. See [1] eq. 163. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_left_inv (const MatrixBase< D > &tangent)
 Inverse of the left Jacobian of SE(2), with tangent = [rho, theta]. More...
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::jac_SE2_right_inv (const MatrixBase< D > &tangent)
 Inverse of the right Jacobian of SE(2), with tangent = [rho, theta]. More...
 
template<typename D >
void wolf::SE2::identity (MatrixBase< D > &p, typename D::Scalar &o)
 
template<typename D1 , typename D2 >
void wolf::SE2::identity (MatrixBase< D1 > &p, MatrixBase< D2 > &o)
 
template<typename D >
void wolf::SE2::identity (MatrixBase< D > &d)
 
template<typename T = double>
Matrix< T, 3, 1 > wolf::SE2::identity ()
 
void wolf::SE2::identity (VectorComposite &v)
 
VectorComposite wolf::SE2::identityComposite ()
 
template<typename D1 , typename D2 >
void wolf::SE2::inverse (const MatrixBase< D1 > &p, const typename D1::Scalar &o, MatrixBase< D2 > &ip, typename D2::Scalar &io)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::inverse (const MatrixBase< D1 > &p, const MatrixBase< D2 > &o, MatrixBase< D3 > &ip, MatrixBase< D4 > &io)
 
template<typename D1 , typename D2 >
void wolf::SE2::inverse (const MatrixBase< D1 > &d, MatrixBase< D2 > &id)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::inverse (const MatrixBase< D > &d)
 
void wolf::SE2::inverse (const VectorComposite &v, VectorComposite &c)
 
VectorComposite wolf::SE2::inverse (const VectorComposite &v)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::compose (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pc, typename D3::Scalar &oc)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::compose (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &pc, MatrixBase< D8 > &oc)
 
template<class D1 , class D2 , class D3 >
void wolf::SE2::compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2, MatrixBase< D3 > &_delta1_compose_delta2)
 
template<class D1 , class D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2)
 
template<class D1 , class D2 , class D3 , class D4 , class D5 >
void wolf::SE2::compose (const MatrixBase< D1 > &_delta1, const MatrixBase< D2 > &_delta2, MatrixBase< D3 > &_delta1_compose_delta2, MatrixBase< D4 > &_J_compose_delta1, MatrixBase< D5 > &_J_compose_delta2)
 
void wolf::SE2::compose (const VectorComposite &_x1, const VectorComposite &_x2, VectorComposite &_c)
 
VectorComposite wolf::SE2::compose (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::between (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &p12, typename D3::Scalar &o12)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::between (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &p12, MatrixBase< D8 > &o12)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::between (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &d12)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::between (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void wolf::SE2::between (const VectorComposite &x1, const VectorComposite &x2, VectorComposite &x12)
 
VectorComposite wolf::SE2::between (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 >
void wolf::SE2::exp (const MatrixBase< D1 > &rho, const typename D1::Scalar &theta, MatrixBase< D2 > &p, typename D2::Scalar &o)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::exp (const MatrixBase< D1 > &rho, const MatrixBase< D2 > &theta, MatrixBase< D3 > &p, MatrixBase< D4 > &o)
 
template<class D1 , class D2 >
void wolf::SE2::exp (const MatrixBase< D1 > &_tau, MatrixBase< D2 > &_delta)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::exp (const MatrixBase< D > &_tau)
 
template<class D1 , class D2 , class D3 >
void wolf::SE2::exp (const MatrixBase< D1 > &_tau, MatrixBase< D2 > &_delta, MatrixBase< D3 > &_J_delta_tau)
 
void wolf::SE2::exp (const VectorComposite &_tau, VectorComposite &_delta)
 
VectorComposite wolf::SE2::exp (const VectorComposite &tau)
 
template<typename D1 , typename D2 >
void wolf::SE2::log (const MatrixBase< D1 > &p, const typename D1::Scalar &o, MatrixBase< D2 > &rho, typename D2::Scalar &theta)
 
template<typename D1 , typename D2 , typename D3 , typename D4 >
void wolf::SE2::log (const MatrixBase< D1 > &p, const MatrixBase< D2 > &o, MatrixBase< D3 > &rho, MatrixBase< D4 > &theta)
 
template<class D1 , class D2 >
void wolf::SE2::log (const MatrixBase< D1 > &_delta, MatrixBase< D2 > &_tau)
 
template<typename D >
Matrix< typename D::Scalar, 3, 1 > wolf::SE2::log (const MatrixBase< D > &_delta)
 
template<class D1 , class D2 , class D3 >
void wolf::SE2::log (const MatrixBase< D1 > &_delta, MatrixBase< D2 > &_tau, MatrixBase< D3 > &_J_tau_delta)
 
void wolf::SE2::log (const VectorComposite &_delta, VectorComposite &_tau)
 
VectorComposite wolf::SE2::log (const VectorComposite &delta)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::plus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &plus_p, typename D3::Scalar &plus_o)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::plus (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &plus_p, MatrixBase< D8 > &plus_o)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::plus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &d_plus)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::plus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void wolf::SE2::plus (const VectorComposite &x, const VectorComposite &tau, VectorComposite &res)
 
VectorComposite wolf::SE2::plus (const VectorComposite &x, const VectorComposite &tau)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pd, typename D3::Scalar &od)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus (const MatrixBase< D1 > &p1, const typename D1::Scalar &o1, const MatrixBase< D2 > &p2, const typename D2::Scalar &o2, MatrixBase< D3 > &pd, typename D3::Scalar &od, typename D3::Scalar &J_do_o1, typename D3::Scalar &J_do_o2)
 
template<typename D1 , typename D2 , typename D4 , typename D5 , typename D7 , typename D8 >
void wolf::SE2::minus (const MatrixBase< D1 > &p1, const MatrixBase< D2 > &o1, const MatrixBase< D4 > &p2, const MatrixBase< D5 > &o2, MatrixBase< D7 > &pd, MatrixBase< D8 > &od)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &err)
 
template<typename D1 , typename D2 , typename D3 , typename D4 , typename D5 >
void wolf::SE2::minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, MatrixBase< D3 > &dif, MatrixBase< D4 > &J_diff_d1, MatrixBase< D5 > &J_diff_d2)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::minus (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2)
 
void wolf::SE2::minus (const VectorComposite &x1, const VectorComposite &x2, VectorComposite &res)
 
VectorComposite wolf::SE2::minus (const VectorComposite &x1, const VectorComposite &x2)
 
template<typename D1 , typename D2 , typename D3 >
void wolf::SE2::interpolate (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, const typename D1::Scalar &t, MatrixBase< D3 > &ret)
 
template<typename D1 , typename D2 >
Matrix< typename D1::Scalar, 3, 1 > wolf::SE2::interpolate (const MatrixBase< D1 > &d1, const MatrixBase< D2 > &d2, const typename D1::Scalar &t)
 
void wolf::SE2::interpolate (const VectorComposite &x1, const VectorComposite &x2, const double &t, VectorComposite &res)
 
VectorComposite wolf::SE2::interpolate (const VectorComposite &x1, const VectorComposite &x2, const double &t)
 
template<typename D1 , typename D2 >
void wolf::SE2::toSE2 (const MatrixBase< D1 > &pose, MatrixBase< D2 > &SE2)
 
template<typename D >
Matrix< typename D::Scalar, 3, 3 > wolf::SE2::toSE2 (const MatrixBase< D > &pose)